home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / IDLIncludes / Math64.idl < prev    next >
Text File  |  1996-05-01  |  5KB  |  147 lines
  1. /*
  2.      File:        Math64.idl
  3.  
  4.      Contains:    64-bit integer math Interfaces.
  5.  
  6.      Version:    Technology:    System 8
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. */
  18. #ifndef __MATH64_IDL__
  19. #define __MATH64_IDL__
  20.  
  21. #include <somobj.idl>
  22. #include <somcls.idl>
  23.  
  24. #ifndef __TYPES_IDL__
  25. #include <Types.idl>
  26. #endif
  27.  
  28. #ifdef __SOMIDL__
  29.  
  30. /*
  31. --------------------------------------------------------------------------------
  32.                 These routines are intended to provide C software support for
  33.                 64 bit integer types.  Their behavior should mimic anticipated
  34.                 64 bit hardware. This implementation should replace use of the
  35.                 "wide" type found in PowerPC.
  36.  
  37.     The following routines are available for performing math on 64-bit integers:
  38.     
  39.     S64Max
  40.                 Returns the largest representable SInt64.
  41.     S64Min
  42.                 Returns the smallest (i.e. most negative) SInt64.  Note: the negative
  43.                 (absolute value) of this number is not representable in an SInt64.
  44.                 That means that S64Negate(S64Min) is not representable (in fact,
  45.                 it returns S64Min).
  46.     S64Add
  47.                 Adds two integers, producing an integer result.  If an overflow
  48.                 occurs the result is congruent mod (2^64) as if the operands and
  49.                 result were unsigned.  No overflow is signaled.
  50.     
  51.     S64Subtract
  52.                 Subtracts two integers, producing an integer result.  If an overflow
  53.                 occurs the result is congruent mod (2^64) as if the operands and
  54.                 result were unsigned.  No overflow is signaled.
  55.  
  56.     S64Negate
  57.                 Returns the additive inverse of a signed number (i.e. it returns
  58.                 0 - the number).  S64Negate (S64Min) is not representable (in fact,
  59.                 it returns S64Min).
  60.     
  61.     S64Absolute
  62.                 Returns the absolute value of the number (i.e. the number if
  63.                 it is positive, or 0 - the number if it is negative).
  64.                 See S64Negate above.
  65.                 
  66.     S64Multiply
  67.                 Multiplies two signed numbers, producing a signed result.  Overflow
  68.                 is ignored and the low-order part of the product is returned.  The
  69.                 sign of the result is not guaranteed to be correct if the magnitude
  70.                 of the product is not representable.
  71.     S64Divide
  72.                 Divides dividend by divisor, returning the quotient.  The remainder
  73.                 is returned in *remainder if remainder (the pointer) is non-NULL.
  74.                 The sign of the remainder is the same as the sign of the dividend
  75.                 (i.e. it takes the absolute values of the operands, does the division,
  76.                 then fixes the sign of the quotient and remainder).  If the divisor
  77.                 is zero, then S64Max() will be returned (or S64Min() if the dividend
  78.                 is negative), and the remainder will be the dividend; no error is
  79.                 reported.
  80.     
  81.     S64Set
  82.                 Given an SInt32, returns an SInt64 with the same value.  Use this
  83.                 routine instead of coding 64-bit constants (at least when the
  84.                 constant will fit in an SInt32).
  85.     
  86.     S64SetU
  87.                 Given a UInt32, returns a SInt64 with the same value.
  88.     
  89.     S64Compare
  90.                 Given two signed numbers, left and right, returns an
  91.                 SInt32 that compares with zero the same way left compares with
  92.                 right.  If you wanted to perform a comparison on 64-bit integers
  93.                 of the form:
  94.                         operand_1 <operation> operand_2
  95.                 then you could use an expression of the form:
  96.                         xxxS64Compare(operand_1,operand_2) <operation> 0
  97.                 to test for the same condition.
  98.                 
  99.                 CAUTION: DO NOT depend on the exact value returned by this routine.
  100.                 Only the sign (i.e. positive, zero, or negative) of the result is
  101.                 guaranteed.
  102.  
  103.     S64And, S64Or, S64Eor and S64Not
  104.     
  105.                 Return Boolean (1 or 0) depending on the outcome of the logical
  106.                 operation.
  107.  
  108.     S64BitwiseAnd, S64BitwiseOr, S64BitwiseEor and S64BitwiseNot
  109.     
  110.                 Return the Bitwise result.
  111.                 
  112.     S64ShiftRight and S64ShiftLeft
  113.     
  114.                 The lower 7 bits of the shift argument determines the amount of 
  115.                 shifting.  S64ShiftRight is an arithmetic shift while U64ShiftRight
  116.                 is a logical shift.
  117.  
  118.     SInt64ToLongDouble
  119.                 
  120.                 Converts SInt64 to long double.  Note all SInt64s fit exactly into 
  121.                 long doubles, thus, the binary -> decimal conversion routines
  122.                 in fp.h can be used to achieve SInt64 -> long double -> decimal
  123.                 conversions.
  124.                 
  125.     LongDoubleToSInt64
  126.     
  127.                 Converts a long double to a SInt64.  Any decimal string that fits
  128.                 into a SInt64 can be converted exactly into a long double, using the
  129.                 conversion routines found in fp.h.  Then this routine can be used
  130.                 to complete the conversion to SInt64.
  131.                 
  132.                 
  133.     
  134.     The corresponding UInt64 routines are also included.
  135.     
  136. --------------------------------------------------------------------------------
  137. */
  138. #if FOR_SYSTEM7_AND_SYSTEM8_PREEMPTIVE
  139. #if GENERATINGPOWERPC
  140. #endif
  141. #endif
  142.  
  143. #endif /* __SOMIDL__ */
  144.  
  145. #endif /* __MATH64_IDL__ */
  146.  
  147.